// $ANTLR 3.4 C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g 2012-10-24 19:28:20

  package practpl.seis;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalexXML extends Lexer {
    public static final int EOF=-1;
    public static final int AAUTOR=4;
    public static final int ABIBLIOTECA=5;
    public static final int AEDITORIAL=6;
    public static final int AETIQUETA=7;
    public static final int AETIQUETACIERRE=8;
    public static final int ALIBRO=9;
    public static final int ATITULO=10;
    public static final int ATRIBUTO=11;
    public static final int ATRIBUTO2=12;
    public static final int BARRA=13;
    public static final int BLANCO=14;
    public static final int CAUTOR=15;
    public static final int CBIBLIOTECA=16;
    public static final int CEDITORIAL=17;
    public static final int CETIQUETA=18;
    public static final int CLIBRO=19;
    public static final int COMENTARIO=20;
    public static final int COMILLAS=21;
    public static final int CTITULO=22;
    public static final int IDENT=23;
    public static final int IGUAL=24;
    public static final int LETRA=25;
    public static final int VALORATR=26;

         private ArrayList<RecognitionException> errors = new ArrayList<RecognitionException>();
         public ArrayList<RecognitionException> getErrors() {
            return errors;
         }
         @Override
         public void reportError (RecognitionException e) {
            String msg = getErrorMessage(e, getTokenNames());
            System.err.println(msg);
            errors.add(e);
         }
         
         boolean abierta = false;


    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public AnalexXML() {} 
    public AnalexXML(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalexXML(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g"; }

    // $ANTLR start "LETRA"
    public final void mLETRA() throws RecognitionException {
        try {
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:30:15: ( ( 'a' .. 'z' ) | ( 'A' .. 'Z' ) | ' ' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:
            {
            if ( input.LA(1)==' '||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LETRA"

    // $ANTLR start "BLANCO"
    public final void mBLANCO() throws RecognitionException {
        try {
            int _type = BLANCO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:32:8: ( ( ' ' | '\\t' | '\\r\\n' ) )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:32:10: ( ' ' | '\\t' | '\\r\\n' )
            {
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:32:10: ( ' ' | '\\t' | '\\r\\n' )
            int alt1=3;
            switch ( input.LA(1) ) {
            case ' ':
                {
                alt1=1;
                }
                break;
            case '\t':
                {
                alt1=2;
                }
                break;
            case '\r':
                {
                alt1=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;

            }

            switch (alt1) {
                case 1 :
                    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:32:11: ' '
                    {
                    match(' '); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:32:15: '\\t'
                    {
                    match('\t'); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:32:20: '\\r\\n'
                    {
                    match("\r\n"); 



                    }
                    break;

            }


            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BLANCO"

    // $ANTLR start "AETIQUETA"
    public final void mAETIQUETA() throws RecognitionException {
        try {
            int _type = AETIQUETA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:34:11: ( '<' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:34:13: '<'
            {
            match('<'); 

            abierta = true;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AETIQUETA"

    // $ANTLR start "CETIQUETA"
    public final void mCETIQUETA() throws RecognitionException {
        try {
            int _type = CETIQUETA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:35:11: ( '>' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:35:13: '>'
            {
            match('>'); 

            abierta = false;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CETIQUETA"

    // $ANTLR start "AETIQUETACIERRE"
    public final void mAETIQUETACIERRE() throws RecognitionException {
        try {
            int _type = AETIQUETACIERRE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:36:16: ( '</' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:36:18: '</'
            {
            match("</"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AETIQUETACIERRE"

    // $ANTLR start "BARRA"
    public final void mBARRA() throws RecognitionException {
        try {
            int _type = BARRA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:38:6: ( '/' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:38:8: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BARRA"

    // $ANTLR start "COMILLAS"
    public final void mCOMILLAS() throws RecognitionException {
        try {
            int _type = COMILLAS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:39:9: ( '\"' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:39:11: '\"'
            {
            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMILLAS"

    // $ANTLR start "IGUAL"
    public final void mIGUAL() throws RecognitionException {
        try {
            int _type = IGUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:40:7: ( '=' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:40:9: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IGUAL"

    // $ANTLR start "IDENT"
    public final void mIDENT() throws RecognitionException {
        try {
            int _type = IDENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:42:7: ( ( LETRA | '.' )+ )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:42:9: ( LETRA | '.' )+
            {
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:42:9: ( LETRA | '.' )+
            int cnt2=0;
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==' '||LA2_0=='.'||(LA2_0 >= 'A' && LA2_0 <= 'Z')||(LA2_0 >= 'a' && LA2_0 <= 'z')) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:
            	    {
            	    if ( input.LA(1)==' '||input.LA(1)=='.'||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IDENT"

    // $ANTLR start "VALORATR"
    public final void mVALORATR() throws RecognitionException {
        try {
            int _type = VALORATR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:43:10: ( COMILLAS IDENT COMILLAS )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:43:12: COMILLAS IDENT COMILLAS
            {
            mCOMILLAS(); 


            mIDENT(); 


            mCOMILLAS(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "VALORATR"

    // $ANTLR start "ATRIBUTO"
    public final void mATRIBUTO() throws RecognitionException {
        try {
            int _type = ATRIBUTO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:45:9: ({...}? ( IDENT IGUAL VALORATR ) )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:45:11: {...}? ( IDENT IGUAL VALORATR )
            {
            if ( !((abierta)) ) {
                throw new FailedPredicateException(input, "ATRIBUTO", "abierta");
            }

            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:45:22: ( IDENT IGUAL VALORATR )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:45:23: IDENT IGUAL VALORATR
            {
            mIDENT(); 


            mIGUAL(); 


            mVALORATR(); 


            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ATRIBUTO"

    // $ANTLR start "ATRIBUTO2"
    public final void mATRIBUTO2() throws RecognitionException {
        try {
            int _type = ATRIBUTO2;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:46:10: ( IDENT IGUAL VALORATR )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:46:12: IDENT IGUAL VALORATR
            {
            mIDENT(); 


            mIGUAL(); 


            mVALORATR(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ATRIBUTO2"

    // $ANTLR start "ABIBLIOTECA"
    public final void mABIBLIOTECA() throws RecognitionException {
        try {
            int _type = ABIBLIOTECA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:50:13: ( AETIQUETA 'biblioteca' ( ATRIBUTO )* CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:50:15: AETIQUETA 'biblioteca' ( ATRIBUTO )* CETIQUETA
            {
            mAETIQUETA(); 


            match("biblioteca"); 



            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:50:38: ( ATRIBUTO )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==' '||LA3_0=='.'||(LA3_0 >= 'A' && LA3_0 <= 'Z')||(LA3_0 >= 'a' && LA3_0 <= 'z')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:50:38: ATRIBUTO
            	    {
            	    mATRIBUTO(); 


            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ABIBLIOTECA"

    // $ANTLR start "CBIBLIOTECA"
    public final void mCBIBLIOTECA() throws RecognitionException {
        try {
            int _type = CBIBLIOTECA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:51:13: ( AETIQUETACIERRE 'biblioteca' CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:51:15: AETIQUETACIERRE 'biblioteca' CETIQUETA
            {
            mAETIQUETACIERRE(); 


            match("biblioteca"); 



            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CBIBLIOTECA"

    // $ANTLR start "ALIBRO"
    public final void mALIBRO() throws RecognitionException {
        try {
            int _type = ALIBRO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:53:8: ( AETIQUETA 'libro' ( ATRIBUTO )* CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:53:10: AETIQUETA 'libro' ( ATRIBUTO )* CETIQUETA
            {
            mAETIQUETA(); 


            match("libro"); 



            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:53:28: ( ATRIBUTO )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==' '||LA4_0=='.'||(LA4_0 >= 'A' && LA4_0 <= 'Z')||(LA4_0 >= 'a' && LA4_0 <= 'z')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:53:28: ATRIBUTO
            	    {
            	    mATRIBUTO(); 


            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ALIBRO"

    // $ANTLR start "CLIBRO"
    public final void mCLIBRO() throws RecognitionException {
        try {
            int _type = CLIBRO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:54:8: ( AETIQUETACIERRE 'libro' CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:54:10: AETIQUETACIERRE 'libro' CETIQUETA
            {
            mAETIQUETACIERRE(); 


            match("libro"); 



            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CLIBRO"

    // $ANTLR start "ATITULO"
    public final void mATITULO() throws RecognitionException {
        try {
            int _type = ATITULO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:56:9: ( AETIQUETA 'titulo' ( ATRIBUTO )* CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:56:11: AETIQUETA 'titulo' ( ATRIBUTO )* CETIQUETA
            {
            mAETIQUETA(); 


            match("titulo"); 



            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:56:30: ( ATRIBUTO )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==' '||LA5_0=='.'||(LA5_0 >= 'A' && LA5_0 <= 'Z')||(LA5_0 >= 'a' && LA5_0 <= 'z')) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:56:30: ATRIBUTO
            	    {
            	    mATRIBUTO(); 


            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);


            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ATITULO"

    // $ANTLR start "CTITULO"
    public final void mCTITULO() throws RecognitionException {
        try {
            int _type = CTITULO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:57:9: ( AETIQUETACIERRE 'titulo' CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:57:11: AETIQUETACIERRE 'titulo' CETIQUETA
            {
            mAETIQUETACIERRE(); 


            match("titulo"); 



            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CTITULO"

    // $ANTLR start "AAUTOR"
    public final void mAAUTOR() throws RecognitionException {
        try {
            int _type = AAUTOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:59:8: ( AETIQUETA 'autor' ( ATRIBUTO )* CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:59:10: AETIQUETA 'autor' ( ATRIBUTO )* CETIQUETA
            {
            mAETIQUETA(); 


            match("autor"); 



            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:59:28: ( ATRIBUTO )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==' '||LA6_0=='.'||(LA6_0 >= 'A' && LA6_0 <= 'Z')||(LA6_0 >= 'a' && LA6_0 <= 'z')) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:59:28: ATRIBUTO
            	    {
            	    mATRIBUTO(); 


            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AAUTOR"

    // $ANTLR start "CAUTOR"
    public final void mCAUTOR() throws RecognitionException {
        try {
            int _type = CAUTOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:60:8: ( AETIQUETACIERRE 'autor' CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:60:10: AETIQUETACIERRE 'autor' CETIQUETA
            {
            mAETIQUETACIERRE(); 


            match("autor"); 



            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CAUTOR"

    // $ANTLR start "AEDITORIAL"
    public final void mAEDITORIAL() throws RecognitionException {
        try {
            int _type = AEDITORIAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:62:12: ( AETIQUETA 'editorial' ( ATRIBUTO )* CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:62:14: AETIQUETA 'editorial' ( ATRIBUTO )* CETIQUETA
            {
            mAETIQUETA(); 


            match("editorial"); 



            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:62:36: ( ATRIBUTO )*
            loop7:
            do {
                int alt7=2;
                int LA7_0 = input.LA(1);

                if ( (LA7_0==' '||LA7_0=='.'||(LA7_0 >= 'A' && LA7_0 <= 'Z')||(LA7_0 >= 'a' && LA7_0 <= 'z')) ) {
                    alt7=1;
                }


                switch (alt7) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:62:36: ATRIBUTO
            	    {
            	    mATRIBUTO(); 


            	    }
            	    break;

            	default :
            	    break loop7;
                }
            } while (true);


            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AEDITORIAL"

    // $ANTLR start "CEDITORIAL"
    public final void mCEDITORIAL() throws RecognitionException {
        try {
            int _type = CEDITORIAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:63:12: ( AETIQUETACIERRE 'editorial' CETIQUETA )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:63:14: AETIQUETACIERRE 'editorial' CETIQUETA
            {
            mAETIQUETACIERRE(); 


            match("editorial"); 



            mCETIQUETA(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CEDITORIAL"

    // $ANTLR start "COMENTARIO"
    public final void mCOMENTARIO() throws RecognitionException {
        try {
            int _type = COMENTARIO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:65:11: ( '<!--' ( . )* '-->' )
            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:65:13: '<!--' ( . )* '-->'
            {
            match("<!--"); 



            // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:65:20: ( . )*
            loop8:
            do {
                int alt8=2;
                int LA8_0 = input.LA(1);

                if ( (LA8_0=='-') ) {
                    int LA8_1 = input.LA(2);

                    if ( (LA8_1=='-') ) {
                        int LA8_3 = input.LA(3);

                        if ( (LA8_3=='>') ) {
                            alt8=2;
                        }
                        else if ( ((LA8_3 >= '\u0000' && LA8_3 <= '=')||(LA8_3 >= '?' && LA8_3 <= '\uFFFF')) ) {
                            alt8=1;
                        }


                    }
                    else if ( ((LA8_1 >= '\u0000' && LA8_1 <= ',')||(LA8_1 >= '.' && LA8_1 <= '\uFFFF')) ) {
                        alt8=1;
                    }


                }
                else if ( ((LA8_0 >= '\u0000' && LA8_0 <= ',')||(LA8_0 >= '.' && LA8_0 <= '\uFFFF')) ) {
                    alt8=1;
                }


                switch (alt8) {
            	case 1 :
            	    // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:65:21: .
            	    {
            	    matchAny(); 

            	    }
            	    break;

            	default :
            	    break loop8;
                }
            } while (true);


            match("-->"); 



            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMENTARIO"

    public void mTokens() throws RecognitionException {
        // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:8: ( BLANCO | AETIQUETA | CETIQUETA | AETIQUETACIERRE | BARRA | COMILLAS | IGUAL | IDENT | VALORATR | ATRIBUTO | ATRIBUTO2 | ABIBLIOTECA | CBIBLIOTECA | ALIBRO | CLIBRO | ATITULO | CTITULO | AAUTOR | CAUTOR | AEDITORIAL | CEDITORIAL | COMENTARIO )
        int alt9=22;
        alt9 = dfa9.predict(input);
        switch (alt9) {
            case 1 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:10: BLANCO
                {
                mBLANCO(); 


                }
                break;
            case 2 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:17: AETIQUETA
                {
                mAETIQUETA(); 


                }
                break;
            case 3 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:27: CETIQUETA
                {
                mCETIQUETA(); 


                }
                break;
            case 4 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:37: AETIQUETACIERRE
                {
                mAETIQUETACIERRE(); 


                }
                break;
            case 5 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:53: BARRA
                {
                mBARRA(); 


                }
                break;
            case 6 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:59: COMILLAS
                {
                mCOMILLAS(); 


                }
                break;
            case 7 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:68: IGUAL
                {
                mIGUAL(); 


                }
                break;
            case 8 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:74: IDENT
                {
                mIDENT(); 


                }
                break;
            case 9 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:80: VALORATR
                {
                mVALORATR(); 


                }
                break;
            case 10 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:89: ATRIBUTO
                {
                mATRIBUTO(); 


                }
                break;
            case 11 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:98: ATRIBUTO2
                {
                mATRIBUTO2(); 


                }
                break;
            case 12 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:108: ABIBLIOTECA
                {
                mABIBLIOTECA(); 


                }
                break;
            case 13 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:120: CBIBLIOTECA
                {
                mCBIBLIOTECA(); 


                }
                break;
            case 14 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:132: ALIBRO
                {
                mALIBRO(); 


                }
                break;
            case 15 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:139: CLIBRO
                {
                mCLIBRO(); 


                }
                break;
            case 16 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:146: ATITULO
                {
                mATITULO(); 


                }
                break;
            case 17 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:154: CTITULO
                {
                mCTITULO(); 


                }
                break;
            case 18 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:162: AAUTOR
                {
                mAAUTOR(); 


                }
                break;
            case 19 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:169: CAUTOR
                {
                mCAUTOR(); 


                }
                break;
            case 20 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:176: AEDITORIAL
                {
                mAEDITORIAL(); 


                }
                break;
            case 21 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:187: CEDITORIAL
                {
                mCEDITORIAL(); 


                }
                break;
            case 22 :
                // C:\\Users\\Elena\\workspace\\seis\\src\\main\\java\\practpl\\seis\\AnalexXML.g:1:198: COMENTARIO
                {
                mCOMENTARIO(); 


                }
                break;

        }

    }


    protected DFA9 dfa9 = new DFA9(this);
    static final String DFA9_eotS =
        "\1\uffff\1\2\1\uffff\1\14\2\uffff\1\22\1\uffff\1\24\1\uffff\1\26"+
        "\22\uffff\1\36\3\uffff";
    static final String DFA9_eofS =
        "\41\uffff";
    static final String DFA9_minS =
        "\1\11\1\40\1\uffff\1\41\2\uffff\1\40\1\uffff\1\40\1\42\1\141\12"+
        "\uffff\1\40\6\uffff\1\40\2\0\2\uffff";
    static final String DFA9_maxS =
        "\2\172\1\uffff\1\164\2\uffff\1\172\1\uffff\1\172\1\42\1\164\12\uffff"+
        "\1\172\6\uffff\1\172\2\0\2\uffff";
    static final String DFA9_acceptS =
        "\2\uffff\1\1\1\uffff\1\3\1\5\1\uffff\1\7\3\uffff\1\26\1\2\1\14\1"+
        "\16\1\20\1\22\1\24\1\6\1\11\1\10\1\uffff\1\4\1\15\1\17\1\21\1\23"+
        "\1\25\3\uffff\1\12\1\13";
    static final String DFA9_specialS =
        "\36\uffff\1\0\2\uffff}>";
    static final String[] DFA9_transitionS = {
            "\1\2\3\uffff\1\2\22\uffff\1\1\1\uffff\1\6\13\uffff\1\10\1\5"+
            "\14\uffff\1\3\1\7\1\4\2\uffff\32\10\6\uffff\32\10",
            "\1\10\15\uffff\1\10\16\uffff\1\11\3\uffff\32\10\6\uffff\32"+
            "\10",
            "",
            "\1\13\15\uffff\1\12\61\uffff\1\20\1\15\2\uffff\1\21\6\uffff"+
            "\1\16\7\uffff\1\17",
            "",
            "",
            "\1\23\15\uffff\1\23\22\uffff\32\23\6\uffff\32\23",
            "",
            "\1\10\15\uffff\1\10\16\uffff\1\11\3\uffff\32\10\6\uffff\32"+
            "\10",
            "\1\25",
            "\1\32\1\27\2\uffff\1\33\6\uffff\1\30\7\uffff\1\31",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\34\15\uffff\1\34\22\uffff\32\34\6\uffff\32\34",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\34\1\uffff\1\35\13\uffff\1\34\22\uffff\32\34\6\uffff\32"+
            "\34",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
    static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
    static final char[] DFA9_min = DFA.unpackEncodedStringToUnsignedChars(DFA9_minS);
    static final char[] DFA9_max = DFA.unpackEncodedStringToUnsignedChars(DFA9_maxS);
    static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
    static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
    static final short[][] DFA9_transition;

    static {
        int numStates = DFA9_transitionS.length;
        DFA9_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA9_transition[i] = DFA.unpackEncodedString(DFA9_transitionS[i]);
        }
    }

    class DFA9 extends DFA {

        public DFA9(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 9;
            this.eot = DFA9_eot;
            this.eof = DFA9_eof;
            this.min = DFA9_min;
            this.max = DFA9_max;
            this.accept = DFA9_accept;
            this.special = DFA9_special;
            this.transition = DFA9_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( BLANCO | AETIQUETA | CETIQUETA | AETIQUETACIERRE | BARRA | COMILLAS | IGUAL | IDENT | VALORATR | ATRIBUTO | ATRIBUTO2 | ABIBLIOTECA | CBIBLIOTECA | ALIBRO | CLIBRO | ATITULO | CTITULO | AAUTOR | CAUTOR | AEDITORIAL | CEDITORIAL | COMENTARIO );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA9_30 = input.LA(1);

                         
                        int index9_30 = input.index();
                        input.rewind();

                        s = -1;
                        if ( ((abierta)) ) {s = 31;}

                        else if ( (true) ) {s = 32;}

                         
                        input.seek(index9_30);

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 9, _s, input);
            error(nvae);
            throw nvae;
        }

    }
 

}